{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "9b19ff2b",
   "metadata": {},
   "source": [
    "# Preface"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a35ba050",
   "metadata": {},
   "source": [
    "\\addcontentsline{toc}{chapter}{Preface}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b0bd590b",
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "107fb946",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <style>\n",
       "        .output_wrapper, .output {\n",
       "            height:auto !important;\n",
       "            max-height:100000px;\n",
       "        }\n",
       "        .output_scroll {\n",
       "            box-shadow:none !important;\n",
       "            webkit-box-shadow:none !important;\n",
       "        }\n",
       "        </style>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#format the book\n",
    "import book_format\n",
    "book_format.set_style()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c5df044",
   "metadata": {},
   "source": [
    "卡尔曼滤波器和贝叶斯滤波器的介绍性教科书。 这本书是使用 Jupyter Notebook 编写的，因此您可以在浏览器中阅读本书，还可以运行和修改代码，查看书中的结果。 有什么更好的学习方式？"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9cfc686c",
   "metadata": {},
   "source": [
    "## Motivation for this Book\n",
    "\n",
    "我是一名在航空航天领域工作了近 20 年的软件工程师，所以我一直在用卡尔曼滤波器“碰碰运气”，但从未实施过。 他们总是以困难着称。 该理论很漂亮，但如果您还没有在信号处理、控制理论、概率和统计以及制导和控制理论等主题方面受过良好训练，则很难学习。 当我开始用计算机视觉解决跟踪问题时，我自己实现它们的需求就变成了\n",
    "紧急。\n",
    "\n",
    "该领域有优秀的教科书，例如 Grewal 和 Andrew 的 *Kalman Filtering*。但是如果您没有必要的背景，坐下来尝试阅读其中的许多书籍是一种令人沮丧和尝试的经历。通常，前几章会快速浏览几年的本科数学，轻松地向您介绍有关伊藤微积分的教科书，并在几段简短的段落中介绍整个学期的统计数据。它们是高年级本科或研究生课程的教科书，也是研究人员和专业人士的宝贵参考，但对于更随意的读者来说，这确实很难。符号介绍不解释，不同的文本对同一概念使用不同的词和变量名称，书中几乎没有例子或工作问题。我经常发现自己能够解析单词并理解定义的数学，但不知道这些单词和数学试图描述的现实世界现象是什么。 “但这*是什么意思？*”是我重复的想法。以下是曾经让我感到困惑的典型例子：\n",
    "\n",
    "$$\\begin{aligned}\\hat{x}_{k} = \\Phi_{k}\\hat{x}_{k-1} + G_k u_{k-1} + K_k [z_k - H \\Phi_{k} \\hat{x}_{k-1} - H G_k u_{k-1}]\n",
    "\\\\ \n",
    "\\mathbf{P}_{k\\mid k} = (I - \\mathbf{K}_k \\mathbf{H}_{k})\\textrm{cov}(\\mathbf{x}_k - \\hat{\\mathbf{x}}_{k\\mid k-1})(I - \\mathbf{K}_k \\mathbf{H}_{k})^{\\text{T}}  + \\mathbf{K}_k\\textrm{cov}(\\mathbf{v}_k )\\mathbf{K}_k^{\\text{T}}\\end{aligned}$$\n",
    "\n",
    "然而，当我开始最终理解卡尔曼滤波器时，我意识到基本概念非常简单。如果你知道一些简单的概率规则，并且对我们如何融合不确定知识有一些直觉，那么卡尔曼滤波器的概念就很容易理解了。卡尔曼滤波器以困难着称，但去掉了许多正式术语，我就清楚这门学科及其数学的美妙之处，我爱上了这个话题。\n",
    "\n",
    "当我开始理解数学和理论时，更多的困难出现了。一本书或论文将陈述一些事实并提供图表作为证据。不幸的是，我不清楚为什么这个陈述是真的，或者我无法重现情节。或者我想知道“如果 R=0，这是真的吗？”或者作者提供了这么高层次的伪代码，实现不明显。有些书提供了 Matlab 代码，但我没有那个昂\n",
    "贵包的许可证。最后，许多书在每一章的结尾都有许多有用的练习。如果您想自己实现卡尔曼滤波器，您需要了解的练习，但没有答案的练习。如果你在课堂上使用这本书，也许这没问题，但对于独立读者来说却很糟糕。我讨厌作者隐瞒我的信息，大概是为了避免学生在课堂上“作弊”。\n",
    "\n",
    "所有这些都阻碍了学习。我想在屏幕上跟踪图像，或者为我的 Arduino 项目编写一些代码。我想知道书中的情节是如何制作的，以及选择与作者选择的参数不同的参数。我想运行模拟。我想在信号中注入更多的噪声，看看滤波器的性能如何。在日常代码中使用卡尔曼滤波器的机会数以千计，但这个相当简单的主题是火箭科学家和学者的出处。\n",
    "\n",
    "我写这本书就是为了满足所有这些需求。如果您设计军用雷达，这不是唯一适合您的书。去一流的 STEM 学校攻读硕士或博士学位，因为你会需要它。本书适用于需要过滤或平滑数据的业余爱好者、好奇心和工作工程师。如果您是业余爱好者，这本书应该会提供您需要的一切。如果您认真对待卡尔曼滤波器，您将需要更多。我的目的是引入足够的概念和数学，使教科书和论文平易近人。\n",
    "\n",
    "这本书是互动的。虽然您可以将其作为静态内容在线阅读，但我强烈建议您按预期使用它。它是使用 Jupyter Notebook 编写的。这允许我将文本、数学、Python 和 Python 输出组合在一个地方。本书中的每一个情节、每一条数据都是由笔记本中的 Python 生成的。想要将参数值加倍？只需更改参数的值，然后按 CTRL-ENTER。将出现一个新的绘图或打印输出。\n",
    "\n",
    "这本书有练习，但也有答案。我相信你。如果您只需要答案，请继续阅读答案。如果您想内化这些知识，请在阅读答案之前尝试实施该练习。由于本书是交互式的，因此您可以在书中输入并运行您的解决方案 - 您不必移动到不同的环境，或者在开始之前处理导入一堆东西。\n",
    "\n",
    "这本书是免费的。我在卡尔曼滤波书籍上花了几千美元。我无法相信他们是经济不景气的人或经济困难的学生可以接触到的。我从 Python 之类的免费软件和 Allen B. Downey [1] 之类的免费书籍中获益良多。是时候回报了。因此，这本书是免费的，它托管在 GitHub 的免费服务器上，并且只使用免费和开放的软件，例如 IPython 和 MathJax。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4026d630",
   "metadata": {},
   "source": [
    "## Kalman and Bayesian Filters\n",
    "\n",
    "传感器有噪音。 世界上充满了我们想要测量和跟踪的数据和事件，但我们不能依靠传感器为我们提供完美的信息。 我车上的 GPS 报告高度。 每次我经过道路上的同一点时，它都会报告略有不同的高度。 如果我称同一个物体两次，我的厨房秤会给我不同的读数。\n",
    "\n",
    "在简单的情况下，解决方案是显而易见的。 如果我的秤给出的读数略有不同，我可以只取一些读数并取平均值。 或者我可以用更准确的比例替换它。 但是当传感器非常嘈杂，或者环境使数据收集变得困难时，我们该怎么办？ 我们可能正试图追踪一架低空飞行的飞机的运动。 我们可能想要为无人机创建自动驾驶仪，或者确保我们的农用拖拉机为整个田地播种。 我从事计算机视觉工作，我需要跟踪图像中的移动对象，而计算机视觉算法会产生非常嘈杂且不可靠的结果。\n",
    "\n",
    "这本书教你如何解决这类过滤问题。 我使用了许多不同的算法，但它们都基于*贝叶斯概率*。 简单来说，贝叶斯概率根据过去的信息确定什么可能是真的。\n",
    "\n",
    "如果我现在问你我车的方向，你会不知道。 您会提供一个介于 1$^\\circ$ 和 360$^\\circ$ 度之间的数字，并且有 360 分之一的机会是正确的。 现在假设我告诉你 2 秒前它的标题是 243$^\\circ$。 在 2 秒内，我的车无法转弯太远，因此您可以做出更准确的预测。 您正在使用过去的信息来更准确地推断关于现在或未来的信息。\n",
    "\n",
    "世界也嘈杂。 该预测可帮助您做出更好的估计，但也会受到噪音的影响。 我可能刚刚为狗刹车或在坑洼周围转弯。 道路上的强风和冰是对我的汽车路径的外部影响。 在控制文献中，我们称之为*噪音*，尽管您可能不这么认为。\n",
    "\n",
    "贝叶斯概率还有更多内容，但您有主要思想。 知识是不确定的，我们会根据证据的强度改变我们的信念。 卡尔曼滤波器和贝叶斯滤波器将我们对系统行为方式的嘈杂和有限知识与嘈杂和有限的传感器读数融合在一起，以产生对系统状态的最佳可能估计。 我们的原则是永不丢弃信息。\n",
    "\n",
    "假设我们正在跟踪一个物体，一个传感器报告它突然改变了方向。 是真的转了，还是数据有噪音？ 这取决于。 如果这是一架喷气式战斗机，我们会非常倾向于相信突然机动的报道。 如果是直轨货运列车，我们会打折。 我们将根据传感器的准确程度进一步修改我们的信念。 我们的信念取决于过去和我们对所跟踪系统的了解以及传感器的特性。\n",
    "\n",
    "卡尔曼滤波器由鲁道夫·埃米尔·卡尔曼 (Rudolf Emil Kálmán) 发明，以数学上最优的方式解决此类问题。 它的第一次使用是在阿波罗登月任务中，从那时起它就被用于各种各样的领域。 飞机、潜艇和巡航导弹上都有卡尔曼滤波器。 华尔街使用它们来跟踪市场。 它们用于机器人、IoT（物联网）传感器和实验室仪器。 化工厂使用它们来控制和监测反应。 它们用于执行医学成像并从心脏信号中去除噪声。 如果涉及传感器和/或时间序列数据，通常会涉及卡尔曼滤波器或卡尔曼滤波器的近亲。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6378fe22",
   "metadata": {},
   "source": [
    "## PDF Version\n",
    "\n",
    "我会定期从笔记本中生成这本书的 PDF。 你可以在这里访问它：\n",
    "\n",
    "https://drive.google.com/file/d/0By_SW19c1BfhSVFzNHc0SjduNzg/view?usp=sharing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d421fd1a",
   "metadata": {},
   "source": [
    "## Jupyter\n",
    "\n",
    "首先，关于在本书中使用 Jupyter Notebooks 的一些话。 这本书是互动的。 如果您想运行代码示例，特别是如果您想查看动画图，则需要运行代码单元。 我不能教你关于 Jupyter Notebooks 的一切。 然而，有几件事让读者大吃一惊。 您可以访问 http://jupyter.org/ 获取详细文档。\n",
    "\n",
    "首先，您必须始终运行最顶层的代码单元，即带有注释“#format the book”的代码单元。 就在上面。 这不仅设置了您可能不关心的格式，而且还加载了一些必要的模块并进行了一些有关绘图和打印的全局设置。 因此，除非您只是被动阅读，否则请始终运行此单元格。\n",
    "\n",
    "```python\n",
    "%matplotlib inline\n",
    "```\n",
    "\n",
    "导致绘图显示在笔记本内。 Matplotlib 是一个绘图包，如下所述。由于我不明白 Jupyter Notebooks 的默认行为是在外部窗口中生成绘图的原因。\n",
    "\n",
    "`%matplotlib` 中的百分号用于 IPython *magic* - 这些是内核的命令，用于执行不属于 Python 语言的事情。有很多有用的魔法命令，你可以在这里阅读它们：http://ipython.readthedocs.io/en/stable/interactive/magics.html\n",
    "\n",
    "在单元格内运行代码很容易。单击它使其具有焦点（将在其周围绘制一个框），然后按 CTRL-Enter。\n",
    "\n",
    "其次，细胞必须按顺序运行。我将问题分解为几个单元格；如果您尝试跳过并运行第十个代码单元，它几乎肯定不会工作。如果您还没有运行任何东西，只需从 **Cell** 菜单项中选择 *Run All Above*。这是确保一切都已运行的最简单方法。\n",
    "\n",
    "运行单元格后，您通常可以跳来跳去并以不同的顺序重新运行单元格，但并非总是如此。我正在尝试解决这个问题，但有一个权衡。我将在单元格 10 中定义一个变量（例如），然后运行修改单元格 11 和 12 中的变量的代码。如果您返回并再次运行单元格 11，则该变量将具有在单元格 12 中设置的值，并且代码需要在单元格 10 中设置的值。因此，如果您不按顺序运行单元格，有时您会得到奇怪的结果。我的建议是稍微回溯一下，然后运行单元格以再次回到正确的状态。这很烦人，但 Jupyter 笔记本的交互方面弥补了这一点。更好的是，在 GitHub 上提交问题，以便我了解问题并修复它！\n",
    "\n",
    "最后，一些读者报告了某些浏览器中的动画绘图功能存在问题。我无法重现这一点。在本书的部分内容中，我使用了 `%matplotlib notebook` 魔法，它可以进行交互式绘图。如果这些绘图不适合您，请尝试将其更改为 `%matplotlib inline`。您将失去动画绘图，但它似乎适用于所有平台和浏览器。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b74dd7e",
   "metadata": {},
   "source": [
    "## SciPy, NumPy, and Matplotlib\n",
    "\n",
    "SciPy 是一个开源的数学软件集合。 SciPy 中包含 NumPy，它提供数组对象、线性代数、随机数等。 Matplotlib 提供 NumPy 数组的绘图。 SciPy 的模块复制了 NumPy 中的一些功能，同时添加了优化、图像处理等功能。\n",
    "\n",
    "为了让我为本书所做的努力易于管理，我选择假设您知道如何使用 Python 进行编程，并且您也熟悉这些包。 尽管如此，我将花一些时间来说明每个的一些特点； 实际上，您将不得不寻找外部资源来教您详细信息。 SciPy 的主页 https://scipy.org 是一个完美的起点，但您很快就会想要搜索相关教程和/或视频。\n",
    "\n",
    "NumPy、SciPy 和 Matplotlib 不附带默认的 Python 发行版； 如果您没有安装它们，请参阅 *安装 * 附录。\n",
    "\n",
    "我在整本书中都使用了 NumPy 的数组数据结构，所以现在让我们了解一下它们。 我会教你足够多的入门知识； 如果您想成为专家，请参阅 NumPy 的文档。\n",
    "\n",
    "`numpy.array` 实现一维或多维数组。 它的类型是 `numpy.ndarray`，我们将其简称为 ndarray。 您可以使用任何类似列表的对象来构造它。 下面从一个列表构造一个一维数组："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a8fb149f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "x = np.array([1, 2, 3])\n",
    "print(type(x))\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e159d97",
   "metadata": {},
   "source": [
    "使用“import numpy as np”已成为行业标准。\n",
    "\n",
    "您还可以使用元组："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ba985de7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 5, 6])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array((4,5,6))\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b87a2fe",
   "metadata": {},
   "source": [
    "使用嵌套括号创建多维数组："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6919f42d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1, 2, 3],\n",
    "              [4, 5, 6]])\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "3ec6ed16",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 2. 3.]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([1, 2, 3], dtype=float)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6d66d52",
   "metadata": {},
   "source": [
    "您可以使用下标位置访问数组元素："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "245a6477",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1, 2, 3],\n",
    "              [4, 5, 6]])\n",
    "\n",
    "print(x[1,2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "453d73dd",
   "metadata": {},
   "source": [
    "您可以使用切片访问列或行。 用作下标的冒号 (:) 是该行或列中所有数据的简写。 所以 `x[:,0]` 返回第一列中所有数据的数组（0 指定第一列）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "7d8c3666",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 4])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[:, 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e09c442b",
   "metadata": {},
   "source": [
    "我们可以得到第二行："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "dfccb7f4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 5, 6])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[1, :]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca786d8f",
   "metadata": {},
   "source": [
    "获取第二行的最后两个元素："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "47a99f4c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 6])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[1, 1:]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdb56687",
   "metadata": {},
   "source": [
    "与 Python `list` 一样，您可以使用负索引来引用数组的末尾。 -1 指最后一个索引。 因此，获取第二（最后）行的最后两个元素的另一种方法是："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "7f42b6db",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 6])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[-1, -2:]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac2b1143",
   "metadata": {},
   "source": [
    "您可以使用 `+` 运算符执行矩阵加法，但矩阵乘法需要 `dot` 方法或函数。 `*` 运算符执行逐元素乘法，这**不是**您想要的线性代数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "e212ec80",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "addition:\n",
      " [[2. 4.]\n",
      " [6. 8.]]\n",
      "\n",
      "element-wise multiplication\n",
      " [[ 1.  4.]\n",
      " [ 9. 16.]]\n",
      "\n",
      "multiplication\n",
      " [[ 7. 10.]\n",
      " [15. 22.]]\n",
      "\n",
      "dot is also a member of np.array\n",
      " [[ 7. 10.]\n",
      " [15. 22.]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1., 2.],\n",
    "              [3., 4.]])\n",
    "print('addition:\\n', x + x)\n",
    "print('\\nelement-wise multiplication\\n', x * x)\n",
    "print('\\nmultiplication\\n', np.dot(x, x))\n",
    "print('\\ndot is also a member of np.array\\n', x.dot(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30c80610",
   "metadata": {},
   "source": [
    "Python 3.5 为矩阵乘法引入了 `@` 运算符。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "fbe2b567",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 7., 10.],\n",
       "       [15., 22.]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x @ x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e38094fd",
   "metadata": {},
   "source": [
    "这仅在您使用 Python 3.5+ 时才有效。 这本书需要3.6或更高版本，所以我会尽可能使用它。 请注意，运算符要求两个值都是数组。 因此，`x @ 3.` 会引发 ValueError，而 `np.dot(X, 3.)` 工作正常。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8af369e6",
   "metadata": {},
   "source": [
    "您可以使用 `.T` 获得转置，并使用 `numpy.linalg.inv` 获得反转。 SciPy 包还提供了反函数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "531f2a04",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "transpose\n",
      " [[1. 3.]\n",
      " [2. 4.]]\n",
      "\n",
      "NumPy ninverse\n",
      " [[-2.   1. ]\n",
      " [ 1.5 -0.5]]\n",
      "\n",
      "SciPy inverse\n",
      " [[-2.   1. ]\n",
      " [ 1.5 -0.5]]\n"
     ]
    }
   ],
   "source": [
    "import scipy.linalg as linalg\n",
    "print('transpose\\n', x.T)\n",
    "print('\\nNumPy ninverse\\n', np.linalg.inv(x))\n",
    "print('\\nSciPy inverse\\n', linalg.inv(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea317e08",
   "metadata": {},
   "source": [
    "有一些辅助函数，如 `zeros` 来创建一个全零矩阵，`ones` 来获取所有 1，以及 `eye` 来获取单位矩阵。 如果您想要一个多维数组，请使用元组来指定形状。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "fd49be6f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "zeros\n",
      " [0. 0. 0. 0. 0. 0. 0.]\n",
      "\n",
      "zeros(3x2)\n",
      " [[0. 0.]\n",
      " [0. 0.]\n",
      " [0. 0.]]\n",
      "\n",
      "eye\n",
      " [[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "print('zeros\\n', np.zeros(7))\n",
    "print('\\nzeros(3x2)\\n', np.zeros((3, 2)))\n",
    "print('\\neye\\n', np.eye(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a251d3b1",
   "metadata": {},
   "source": [
    "我们有创建等距数据的功能。 `arange` 的工作方式与 Python 的 `range` 函数非常相似，只是它返回一个 NumPy 数组。 `linspace` 的工作方式略有不同，您可以使用 `linspace(start, stop, num)` 调用它，其中 `num` 是您想要的数组的长度。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "b368cf39",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. , 1.1,\n",
       "       1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(0, 2, 0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "7f88fd58",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.   , 0.105, 0.211, 0.316, 0.421, 0.526, 0.632, 0.737, 0.842,\n",
       "       0.947, 1.053, 1.158, 1.263, 1.368, 1.474, 1.579, 1.684, 1.789,\n",
       "       1.895, 2.   ])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(0, 2, 20)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1b053ad",
   "metadata": {},
   "source": [
    "现在让我们绘制一些数据。 在大多数情况下，它非常简单。 Matplotlib 包含一个绘图库“pyplot”。 将其作为“plt”导入是行业标准。 导入后，通过使用数字列表或数组调用“plt.plot”来绘制数字。 如果您进行多次调用，它将绘制多个系列，每个系列都有不同的颜色。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "d750574b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f500c6d8940>]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 900x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "a = np.array([6, 3, 5, 2, 4, 1])\n",
    "plt.plot([1, 4, 2, 5, 3, 6])\n",
    "plt.plot(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0705dfca",
   "metadata": {},
   "source": [
    "输出 `[<matplotlib.lines.Line2D at 0x2ba160bed68>]` 是因为 `plt.plot` 返回刚刚创建的对象。 通常我们不想看到这种情况，所以我在最后一个绘图命令中添加了一个 `;` 来抑制该输出。\n",
    "\n",
    "默认情况下，`plot` 假定 x 系列递增 1。 您可以通过传入 x 和 y 来提供自己的 x 系列。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "fe987504",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 900x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(np.arange(0,1, 0.1), [1,4,3,2,6,4,7,3,4,5]);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f26a7ae5",
   "metadata": {},
   "source": [
    "我在本书中使用了这些包的更多功能。 通常我会不加解释地介绍它们，相信您可以从上下文中推断出用法，或者在网上搜索解释。 与往常一样，如果您不确定，请在 Notebook 中创建一个新单元格或启动 Python 控制台并进行实验！\n",
    "\n",
    "### Exercise -  Create arrays\n",
    "\n",
    "我希望你创建一个包含 10 个元素的 NumPy 数组，每个元素包含 1/10。 做这件事有很多种方法; 尝试尽可能多地实施。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a6c43ceb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# your solution"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a07ae801",
   "metadata": {},
   "source": [
    "### Solution\n",
    "\n",
    "这里有三种方法可以做到这一点。 第一个是我想让你知道的。 我使用“/”运算符将数组的所有元素除以 10。我们很快将使用它来将数组的单位从米转换为千米。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "a06f0992",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1]\n",
      "[0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1]\n",
      "[0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1]\n"
     ]
    }
   ],
   "source": [
    "print(np.ones(10) / 10.)\n",
    "print(np.array([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1]))\n",
    "print(np.array([.1] * 10))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bff7c523",
   "metadata": {},
   "source": [
    "这是我还没有涉及的一个。 函数 `numpy.asarray()` 会将其参数转换为一个 ndarray，如果它还不是一个。 如果是，则数据不变。 这是编写一个可以接受 Python 列表或 ndarray 的函数的便捷方法，如果类型已经是 ndarray，因为没有创建任何新内容，它非常有效。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "b58aa92d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.1 0.2 0.3]\n",
      "[0.4 0.5 0.6]\n"
     ]
    }
   ],
   "source": [
    "def one_tenth(x):\n",
    "    x = np.asarray(x)\n",
    "    return x / 10.\n",
    "\n",
    "print(one_tenth([1, 2, 3]))            # I work!\n",
    "print(one_tenth(np.array([4, 5, 6])))  # so do I!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99216531",
   "metadata": {},
   "source": [
    "## Companion Software\n",
    "\n",
    "我正在编写一个名为 FilterPy 的开源贝叶斯过滤 Python 库。上面给出了安装说明。\n",
    "\n",
    "FilterPy 托管在 GitHub 上（https://github.com/rlabbe/filterpy），但 `pip` 安装版本应该可以满足您的需求。\n",
    "\n",
    "特定于书的代码与书一起存储在子目录**/kf_book** 中。它包含格式化书籍的代码。它还包含名称如 *xxx*_internal.py 的 python 文件。我使用这些来存储对特定章节有用的函数。这使我可以隐藏阅读起来并不特别有趣的 Python 代码——我可能正在生成一个绘图或图表，我希望您专注于图表的内容，而不是我如何使用 Python 生成该图表的机制。如果您对此机制感到好奇，请去浏览源代码。\n",
    "\n",
    "一些章节介绍了对本书其余部分有用的函数。这些函数最初是在 Notebook 本身中定义的，但代码也存储在 **/kf_book** 中的 Python 文件中，如果需要在后面的章节中导入该文件。当我在第一次定义函数的地方执行此操作时，我会记录，但这仍在进行中。我尽量避免这种情况，因为我总是面临目录中的代码与书中的代码不同步的问题。但是，Jupyter Notebook 并没有给我们提供一种方法来引用其他笔记本中的代码单元，所以这是我所知道的在笔记本之间共享功能的唯一机制。\n",
    "\n",
    "有一个名为 **/experiments** 的未记录目录。这是我在将代码放入书中之前编写和测试代码的地方。里面有一些有趣的东西，请随意看看。随着本书的发展，我计划创建示例和项目，并且很多此类材料将在那里结束。小型实验最终将被删除。如果你只是对阅读本书感兴趣，你可以放心地忽略这个目录。\n",
    "\n",
    "\n",
    "目录 **/kf_book** 包含一个 css 文件，其中包含该书的样式指南。 Jupyter Notebook 的默认外观和感觉相当简单。我遵循了诸如[Probabilistic Programming and Bayesian Methods for Hackers]（http://nbviewer.ipython.org/github/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/blob/等书籍设置的示例）主/Chapter1_Introduction/Chapter1.ipynb) [2]。我也深受 Lorena Barba 教授出色的工作的影响，[可在此处获得](https://github.com/barbagroup/CFDPython) [3]。我的所有外观和感觉都归功于这些项目的工作。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b48a56c",
   "metadata": {},
   "source": [
    "## Thoughts on Python and Coding Math"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19f28775",
   "metadata": {},
   "source": [
    "大多数卡尔曼滤波和其他工程文本都是由数学家或学者撰写的。当有软件时（很少），它不是生产质量。以 Paul Zarchan 的《卡尔曼滤波基础知识》一书为例。这是一本非常棒的书，属于您的图书馆，也是为数不多的为每个示例和图表提供完整资源的书籍之一。但是代码是 Fortran，除了调用诸如“MATMUL”之类的函数之外没有任何子例程。卡尔曼滤波器在本书中重新实现。相同的清单将模拟与过滤代码混合在一起，因此很难区分它们。一些章节以略微不同的方式实现相同的过滤器，并使用粗体文本突出显示更改的几行。如果需要 Runge Kutta，它会嵌入到代码中，无需注释。\n",
    "\n",
    "有更好的方法。如果我想执行 Runge Kutta，我调用 ode45，我不会在我的代码中嵌入 Runge Kutta 实现。我不想多次实现 Runge Kutta 并多次调试它。如果我确实发现了一个错误，我可以修复它一次，并确保它现在适用于我所有不同的项目。而且，它是可读的。我很少关心 Runge Kutta 的实施。\n",
    "\n",
    "这是一本关于卡尔曼滤波的教科书，你可以说我们*确实*关心卡尔曼滤波器的实现。没错，但是执行过滤的代码使用了大约 10 行代码。实现数学的代码相当简单。卡尔曼滤波器所需的大部分工作是设计输入数学引擎的矩阵。\n",
    "\n",
    "一个可能的缺点是执行过滤的方程隐藏在函数后面，我们可以说这是教学文本中的损失。我反对相反。我希望您学习如何在现实世界中，为实际项目使用卡尔曼滤波器，并且您不应该到处剪切和粘贴已建立的算法。\n",
    "\n",
    "我使用 Python 类。我主要使用类来组织过滤器所需的数据，而不是实现诸如继承之类的面向对象 (OO) 功能。例如，`KalmanFilter` 类存储称为 `x`、`P`、`R`、`Q`、`S`、`y`、`K` 的矩阵和向量。我见过卡尔曼滤波器的程序库，它们需要程序员维护所有这些矩阵。这对于一个玩具程序来说可能还不错，但是对一组卡尔曼滤波器进行编程，您将不会喜欢管理所有这些矩阵和其他相关数据。我在自己的工作中偶尔会从这些类派生出来，并且觉得它很方便，但我不想强迫人们使用 OO，因为我知道很多人不喜欢它。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c58e671e",
   "metadata": {},
   "source": [
    "## License\n",
    "\n",
    "<a rel=\"license\" href=\"http://creativecommons.org/licenses/by-nc-sa/4.0/\"><img alt=\"Creative Commons License\" style=\"border-width:0\" src=\"http://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png\" /></a><br /><span xmlns:dct=\"http://purl.org/dc/terms/\" property=\"dct:title\">Kalman Filters and Random Signals in Python</span> by <a xmlns:cc=\"http://creativecommons.org/ns#\" href=\"https://github.com/rlabbe/Kalman-Filters-and-Random-Signals-in-Python\" property=\"cc:attributionName\" rel=\"cc:attributionURL\">Roger Labbe</a> is licensed under a <a rel=\"license\" href=\"http://creativecommons.org/licenses/by-nc-sa/4.0/\">Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License</a>.<br />\n",
    "\n",
    "http://creativecommons.org/licenses/by-nc-sa/4.0/\n",
    "\n",
    "Based on the work at <a xmlns:dct=\"http://purl.org/dc/terms/\" href=\"https://github.com/rlabbe/Kalman-and-Bayesian-Filters-in-Python\" rel=\"dct:source\">https://github.com/rlabbe/Kalman-and-Bayesian-Filters-in-Python</a>.\n",
    "\n",
    "## Contact\n",
    "\n",
    "rlabbejr@gmail.com\n",
    "\n",
    "## Resources\n",
    "\n",
    "* [1] http://www.greenteapress.com/\n",
    "* [2] http://nbviewer.ipython.org/github/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/blob/master/Chapter1_Introduction/Chapter1.ipynb\n",
    "* [3] https://github.com/barbagroup/CFDPython"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
